home *** CD-ROM | disk | FTP | other *** search
/ Revista do CD-ROM 101 / CD-ROM 101.iso / compl / maya5ple / Install_MayaPLE5_English.exe / Maya / Data1.cab / WindowMenu.mel < prev    next >
Encoding:
Text File  |  2003-07-17  |  18.5 KB  |  576 lines
  1. // Copyright (C) 1997-2002 Alias|Wavefront,
  2. // a division of Silicon Graphics Limited.
  3. //
  4. // The information in this file is provided for the exclusive use of the
  5. // licensees of Alias|Wavefront.  Such users have the right to use, modify,
  6. // and incorporate this code into other products for purposes authorized
  7. // by the Alias|Wavefront license agreement, without fee.
  8. //
  9. // ALIAS|WAVEFRONT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  10. // INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  11. // EVENT SHALL ALIAS|WAVEFRONT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  12. // CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  13. // DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  14. // TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15. // PERFORMANCE OF THIS SOFTWARE.
  16. //
  17. //
  18. //  Alias|Wavefront Script File
  19. //  MODIFY THIS AT YOUR OWN RISK
  20. //
  21. //  Creation Date:  Aug 15 1996
  22. //
  23. //  Description:
  24. //      This file creates the window menu
  25. //
  26.  
  27. // This string points to the relationship editor pulldown menu in the
  28. // main window.  If plugins add new tasks, they can add their popup menu
  29. // items to this menu.
  30. global string $relationshipEditorPulldownMenu = "";
  31.  
  32. // These strings point to procedures for adding and removing tasks to the
  33. // relationship editor.  They are managed by the relationshipEditorRegisterTask
  34. // global procedure that plugin writers can call.
  35. global string $relationshipEditorRegisterCB[] = {};
  36. global string $relationshipEditorUnregisterCB[] = {};
  37.  
  38. global proc string[] getRelationshipEdPopups()
  39. //
  40. // Description:
  41. //    This procedure finds and returns the popup task menu for all relationship
  42. //  editors.  This list is used to allow plugins to register their own tasks.
  43. //
  44. {
  45.     string $popups[];
  46.     string $controls[] = `lsUI -long -controls`;
  47.     
  48.     // Look for controls whose leaf name is "taskPopup".
  49.     for ($c in $controls) {
  50.         string $tokens[];
  51.         int $numTokens = `tokenize $c "|" $tokens`;
  52.         if ($tokens[$numTokens-1] == "taskPopup")
  53.             $popups[size($popups)] = $c;
  54.     }
  55.     
  56.     return $popups;
  57. }
  58.  
  59. global proc int relationshipEditorRegisterTask(
  60.         string $registerCB,
  61.         string $unregisterCB)
  62. //
  63. // Description:
  64. //    This procedure saves the two callbacks for registering and unregistering
  65. //  a task for the relationship editor.  The callbacks are used to add and
  66. //  remove the popup UI which makes the tasks visible to the user.  An id
  67. //  number is returned to the caller to use when unregistering the task.
  68. //
  69. {
  70.     global string $relationshipEditorPulldownMenu;
  71.     global string $relationshipEditorRegisterCB[];
  72.     global string $relationshipEditorUnregisterCB[];
  73.     
  74.     // Use the next available index as the id.
  75.     int $id = size($relationshipEditorRegisterCB);
  76.     
  77.     // Store the callback procedures.
  78.     $relationshipEditorRegisterCB[$id] = $registerCB;
  79.     $relationshipEditorUnregisterCB[$id] = $unregisterCB;
  80.     
  81.     // If the main menu pulldown or the relationship editor popup 
  82.     // have already been created, call the registerCB.
  83.     if ($relationshipEditorPulldownMenu != "") {
  84.     
  85.         // Call the register CB at least once for the main menu pulldown.
  86.         eval($registerCB + " foo");
  87.         
  88.         // Get the relationship editor task popups and register the plugin
  89.         // UI for each one.
  90.         string $taskPopups[] = getRelationshipEdPopups();
  91.         for ($popup in $taskPopups)
  92.             eval($registerCB + " " + $popup);
  93.     }
  94.     
  95.     return $id;
  96. }
  97.  
  98. global proc relationshipEditorUnregisterTask(int $taskId)
  99. //
  100. // Description:
  101. //    This procedure unregisters that task specified by the given id.
  102. //
  103. {
  104.     global string $relationshipEditorPulldownMenu;
  105.     global string $relationshipEditorRegisterCB[];
  106.     global string $relationshipEditorUnregisterCB[];
  107.     
  108.     // If the task id is not valid, just return.
  109.     if (($taskId < 0) || ($taskId >= size($relationshipEditorRegisterCB)))
  110.         return;
  111.         
  112.     // If the relationship editor or the main window pulldown have been created,
  113.     // call the unregisterCB for each relationship editor.
  114.     if ($relationshipEditorPulldownMenu != "") {
  115.     
  116.         // Call the unregister CB at least once for the main menu pulldown.
  117.         eval($relationshipEditorUnregisterCB[$taskId] + " foo");
  118.         
  119.         // Get the relationship editor task popups and unregister the plugin
  120.         // UI for each one.
  121.         string $taskPopups[] = getRelationshipEdPopups();
  122.         for ($popup in $taskPopups)
  123.             eval($relationshipEditorUnregisterCB[$taskId] + " " + $popup);
  124.     }
  125.         
  126.     // Clear the callback procedures.
  127.     $relationshipEditorRegisterCB[$taskId] = "";
  128.     $relationshipEditorUnregisterCB[$taskId] = "";
  129. }
  130.  
  131. global proc addRelationshipEdPluginItems(string $popup)
  132. //
  133. // Description:
  134. //    This procedure is called when the relationship editor is built.  It
  135. //  creates the UI for any tasks registered by plugins.
  136. //
  137. {
  138.     global string $relationshipEditorRegisterCB[];
  139.     
  140.     // Call the register callback for each registered plugin.
  141.     for ($cb in $relationshipEditorRegisterCB) {
  142.         if ($cb != "")
  143.             eval($cb + " " + $popup);
  144.     }
  145. }
  146.  
  147. global proc buildObjectEdMenu( string $parent ) {
  148.  
  149.     global string $gCommandWindow;
  150.  
  151.     setParent -m $parent;
  152.  
  153.     if( `menu -q -ni $parent` != 0 ) {
  154.         //
  155.         //    Menu is already built - just return
  156.         //
  157.         return;
  158.     }
  159.     menuItem -ecr false -l "Component Editor..."
  160.          -annotation "Component Editor: Edit various component values for the selected object(s)"
  161.         -imageOverlayLabel "CpEd"
  162.          -c "ComponentEditor";
  163.     menuItem -ecr false -l "Attribute Spread Sheet..." 
  164.         -annotation "Attribute Spread Sheet: Edit the attributes of the selected object(s)"
  165.         -imageOverlayLabel "SpSh"
  166.         -c "SpreadSheetEditor";
  167.     menuItem -ecr false -l "Connection Editor..." 
  168.         -annotation "Connection Editor: Make connections between object attributes"
  169.         -c "ConnectionEditor";
  170.     menuItem -ecr false -l "Visor..." 
  171.         -annotation "Visor: Visual organizer that displays images of shading nodes"
  172.         -c "VisorWindow";
  173.  
  174.     // Blind data editor
  175.     menuItem -divider true;
  176.     menuItem -l "Blind Data Editor..."
  177.         -c "BlindDataEditor"
  178.         -ecr false
  179.         -ann "Blind Data Editor: Create blind data types and apply, query, or false color blind data"
  180.         blindDataEditorItem;
  181.  
  182.     menuItem -divider true;
  183.  
  184.     menuItem -ecr false -l "Channel Control..." 
  185.         -annotation "Channel Control: Set the keyable state of attributes of the selected object(s)"
  186.         -c "ChannelControlEditor";
  187.     // menuItem -l "Panel Camera Attributes..." -c "showPanelCameraEditor \"\"";
  188.  
  189.     menuItem -divider true;
  190.  
  191.     menuItem -ecr false -l "Script Editor..." 
  192.         -annotation "Script Editor: Enter Maya Embedded Language (MEL) commands"
  193.         -c "ScriptEditor"; 
  194.     if (!`about -mac`) {
  195.         menuItem -ecr false -l "Command Shell..." 
  196.             -annotation "Command Shell: Open a Command Shell window to enter MEL commands one line at a time"
  197.             -c "CommandShell"; 
  198.     }
  199. }
  200.  
  201. global proc buildRenderingEdMenu( string $parent ) {
  202.  
  203.     popupMenu -e -deleteAllItems $parent;
  204.     setParent -m $parent;
  205.  
  206.     if( `menu -q -ni $parent` != 0 ) {
  207.         //
  208.         //    Menu is already built - just return
  209.         //
  210.         return;
  211.     }
  212.     menuItem -ecr false -l "Render View..." 
  213.         -annotation "Render View: Display rendering image"
  214.         -c "RenderViewWindow";
  215.     
  216.     if (`licenseCheck -m "edit" -typ "complete"`) {
  217.         menuItem -ecr false -l "Hardware Render Buffer..." 
  218.             -annotation "Hardware Render Buffer: Display the scene through the camera selected for hardware rendering"
  219.             -c "HardwareRenderBuffer";
  220.     }
  221.  
  222.     menuItem -divider true;
  223.  
  224.     // Create a render globals menu item for each available renderer
  225.     //
  226.     string $renderers[] = `renderer -query -namesOfAvailableRenderers`;
  227.     string $rendererUIName = "";
  228.     string $command = "displayRenderGlobalsWindow";
  229.  
  230.     if ($command != "")
  231.     {
  232.         menuItem 
  233.             -enableCommandRepeat false 
  234.             -label ("Render Globals ...")
  235.             -annotation "Render Globals: Change global rendering attributes"
  236.             -command $command;
  237.     }
  238.  
  239.     menuItem -ecr false -l "Hypershade..." 
  240.         -annotation "Hypershade: Display and edit connections in shading networks"
  241.         -imageOverlayLabel "Hshd"
  242.         -c "HypershadeWindow";
  243.  
  244.     menuItem -divider true;
  245.  
  246.     menuItem -ecr false -l "Rendering Flags..." 
  247.         -annotation "Rendering Flags: Change the rendering preferences"
  248.         -c "RenderFlagsWindow";
  249.     menuItem -ecr false -l "Shading Group Attributes..."
  250.         -annotation "Shading Group Attributes: Object by object shader properties"
  251.         -c "ShadingGroupAttributeEditor";
  252.  
  253.     menuItem -divider true;
  254.  
  255.     menuItem -ecr false -l "Multilister..." 
  256.         -annotation "Multilister: Create and edit shading nodes, and assign them to objects in your scene"
  257.          -c "Multilister";
  258.  
  259.     menuItem -divider true;
  260.  
  261.     // Create renderer specific submenus for any additional renderers installed
  262.  
  263.     for ($i = 0; $i < size($renderers); $i += 1)
  264.     {
  265.         $command = `renderer -query -renderingEditorsSubMenuProcedure $renderers[$i]`;
  266.  
  267.         if($command != "")
  268.         {
  269.             $rendererUIName = `renderer -query -rendererUIName $renderers[$i]`;
  270.  
  271.                menuItem
  272.                 -subMenu                true
  273.                 -label                    $rendererUIName
  274.                 -annotation
  275.                     "Additional renderer specific option"
  276.                 ("rendererOptionsItem" + $renderers[$i]);
  277.  
  278.             menuItem
  279.                 -edit
  280.                 -postMenuCommand
  281.                     ("eval " + $command +
  282.                      " rendererOptionsItem" + $renderers[$i])
  283.                 ("rendererOptionsItem" + $renderers[$i]);
  284.  
  285.             setParent -menu ..;
  286.         }
  287.     }
  288. }
  289.  
  290. global proc buildAnimationEdMenu( string $parent ) {
  291.     setParent -m $parent;
  292.     int $completeLicense = `licenseCheck -m "edit" -typ "complete"`;        
  293.  
  294.     if( `menu -q -ni $parent` != 0 ) {
  295.         //
  296.         //    Menu is already built - just return
  297.         //
  298.         return;
  299.     }
  300.     menuItem -ecr false -l "Graph Editor..." 
  301.         -annotation "Graph Editor: Edit animation curves"
  302.         -c "GraphEditor";
  303.  
  304.     menuItem  -ecr false -l "Trax Editor..." 
  305.         -annotation "Trax Editor: Non-Linear Character Animation Editor"
  306.         -c "CharacterAnimationEditor";
  307.     
  308.     menuItem  -ecr false -l "Dope Sheet..." 
  309.         -annotation "Dope Sheet: Perform high-level timing and animation event and sound synchronization editing"
  310.         -c "DopeSheetEditor";
  311.  
  312.     if ($completeLicense) {
  313.         menuItem  -ecr false -l "Blend Shape..." 
  314.             -annotation "Blend Shape: Adjust Blend Shape weights"
  315.             -imageOverlayLabel "Blnd"
  316.             -c "BlendShapeEditor";
  317.     }
  318.  
  319.     menuItem -divider true;
  320.     menuItem -ecr false -l "Expression Editor..." 
  321.         -annotation "Expression Editor: Edit expressions between attributes"
  322.         -c "ExpressionEditor" expressionItem;
  323.     
  324.     if(!`about -mac`){
  325.         menuItem -divider true;
  326.         menuItem  -ecr false -l "Device Editor..." 
  327.             -annotation "Device Editor: Attach input devices to commands or objects"
  328.             -c "DeviceEditor";
  329.     }
  330. }
  331.  
  332. global proc buildLightLinkingEdMenu( string $parent ) {
  333.     setParent -m $parent;
  334.  
  335.     if( `menu -q -ni $parent` != 0 ) {
  336.         //
  337.         //    Menu is already built - just return
  338.         //
  339.         return;
  340.     }
  341.     menuItem -ecr false -l "Light-Centric..."
  342.      -annotation "Light-Centric Light Linking: Specify the object(s) illuminated by particular lights"
  343.       -c "LightCentricLightLinkingEditor";
  344.     menuItem -ecr false -l "Object-Centric..." 
  345.         -annotation "Object-Centric Light Linking: Specify which light(s) illuminate particular geometry"
  346.         -c "ObjectCentricLightLinkingEditor";
  347. }
  348.  
  349. global proc buildUvLinkingEdMenu( string $parent ) {
  350.     global string $uvMainLinkMenu;
  351.     global string $furUVLinkMenuItem;
  352.     $uvMainLinkMenu = $parent;
  353.  
  354.     setParent -m $parent;
  355.  
  356.     if( `menu -q -ni $parent` != 0 ) {
  357.         //
  358.         //    Menu is already built - just return
  359.         //
  360.         return;
  361.     }
  362.     menuItem -ecr false -l "Texture-Centric..."
  363.      -annotation "Texture-Centric UV Linking: Specify which UV set is used by a particular texture"
  364.       -c "TextureCentricUVLinkingEditor";
  365.     menuItem -ecr false -l "UV-Centric..." 
  366.         -annotation "UV-Centric UV Linking: Specify which textures use a particular UV set"
  367.         -c "UVCentricUVLinkingEditor";
  368.     
  369.     //Maya Fur Plugin Fur/UV Linking Menu
  370.     if (`pluginInfo -q -l Fur`) {
  371.             $furUVLinkMenuItem = `menuItem -ecr false -l "Fur/UV..." 
  372.             -annotation (getRunTimeCommandAnnotation("FurUVSetLinkingEditor"))
  373.             -c "FurUVSetLinkingEditor"`;
  374.     }
  375. }
  376.  
  377. global proc buildRelationshipEdMenu( string $parent )
  378. {    
  379.     // Make the parent menu available to plugins who want to add their own
  380.     // relationships.  This variable is defined in relationshipEditor.mel.
  381.     global string $relationshipEditorPulldownMenu;
  382.     $relationshipEditorPulldownMenu = $parent;
  383.     
  384.     setParent -m $parent;
  385.  
  386.     if( `menu -q -ni $parent` != 0 ) {
  387.         //
  388.         //    Menu is already built - just return
  389.         //
  390.         return;
  391.     }
  392.     menuItem -ecr false -l "Sets..."
  393.      -annotation "Set Editor: Edit set membership"
  394.       -c "SetEditor";
  395.     menuItem -ecr false -l "Deformer Sets..." 
  396.         -annotation "Deformer Set Editor: Edit deformer set membership"
  397.         -c "DeformerSetEditor";
  398.     
  399.     menuItem -ecr false -l "Character Sets..."
  400.      -annotation "Character Set Editor: Edit character set membership"
  401.       -c "CharacterSetEditor";
  402.  
  403.     menuItem -ecr false -l "Partitions..."
  404.      -annotation "Partition Editor: Edit partition membership"
  405.       -c "PartitionEditor";
  406.     menuItem -ecr false -l "Display Layers..."
  407.         -annotation "Layer Editor: Edit display layer membership"
  408.         -c "LayerRelationshipEditor";
  409.     menuItem -ecr false -l "Render Layers..."
  410.      -annotation "Render Layer Editor: Edit render layer membership"
  411.       -c "RenderLayerRelationshipEditor";
  412.     if( `licenseCheck -m edit -type complete` == 1 )
  413.     {
  414.         menuItem  -ecr false -l "Dynamic Relationships..." 
  415.             -annotation "Dynamic Relationships: Edit dynamic connections to the objects"
  416.             -c "DynamicRelationshipEditor";
  417.     }
  418.  
  419.     $menu = `menuItem -l "Light Linking" -sm true -to true`;
  420.         menu -e -pmc ( "buildLightLinkingEdMenu " + $menu ) $menu;
  421.     setParent -m $parent;
  422.  
  423.     $menu = `menuItem -l "UV Linking" -sm true -to true`;
  424.         menu -e -pmc ( "buildUvLinkingEdMenu " + $menu ) $menu;
  425.     setParent -m $parent;
  426.     
  427.     // Add any items from plugins.
  428.     addRelationshipEdPluginItems("foo");
  429. }
  430.  
  431. global proc buildSettingsMenu( string $parent ) 
  432. {
  433.     setParent -m $parent;
  434.  
  435.     if( `menu -q -ni $parent` != 0 ) {
  436.         //
  437.         //    Menu is already built - just return
  438.         //
  439.         return;
  440.     }
  441.  
  442.     menuItem -ecr false -label "Preferences..." 
  443.         -annotation "Preferences: Set and save Maya preferences" 
  444.         -c "PreferencesWindow";
  445.     menuItem  -ecr false -l "Tool Settings..." 
  446.         -annotation "Tool Settings: Edit settings for current tool"
  447.         -c "ToolSettingsWindow";
  448.     menuItem -ecr false -l "Performance Settings..." 
  449.         -annotation "Performance Settings: Edit settings affecting scene evaluation"
  450.         -c "PerformanceSettingsWindow";
  451.  
  452.     menuItem -divider true;
  453.  
  454.     menuItem -ecr false -label "Hotkeys..." 
  455.         -annotation "Hotkey Preferences: Create, edit and save hotkeys" 
  456.         -c "HotkeyPreferencesWindow";
  457.  
  458.     menuItem -ecr false -label "Colors..." 
  459.         -annotation "Color Preferences: Set colors for the Maya UI" 
  460.         -c "ColorPreferencesWindow";
  461.  
  462.     menuItem  -ecr false -l "Marking Menus..." 
  463.         -annotation "Marking Menu Editor: Customize the layout of the Marking Menus"
  464.         -c "MarkingMenuPreferencesWindow";
  465.  
  466.     menuItem  -ecr false -l "Shelves..." 
  467.         -annotation "Shelf Editor: Edit the contents of the Shelf"
  468.         -c "ShelfPreferencesWindow" shelfOptionsItem;
  469.  
  470.     menuItem  -ecr false -l "Panels..." 
  471.         -annotation "Panel Editor: Edit the Panel Layout"
  472.         -c "PanelPreferencesWindow";
  473.  
  474.     menuItem -divider true;
  475.  
  476.     menuItem -ecr false -l "Plug-in Manager..." 
  477.         -annotation "Plug-in Manager: Load or automatically load plug-ins"
  478.         -c "PluginManager";
  479. }
  480.  
  481. global proc openAEWindow( )
  482. //
  483. //    Description:
  484. //        Opens an AE window, IF the attribute editor isn't
  485. //        in the main Maya window pane already.
  486. //
  487. {
  488.     global string $gAttributeEditorForm;
  489.  
  490.     if( !`isAttributeEditorVisible` ) {
  491.  
  492.         editSelected;
  493.  
  494.     } else {
  495.         if ( `optionVar -q aeInMainWindow` ){
  496.             string $errorMessage =
  497.                 "The Attribute Editor is already in the main Maya window.\n"
  498.                 + "// To put the Attribute Editor in a separate window you must:\n"
  499.                 + "//  - Open \"Window > Settings/Preferences > Preferences\"\n"
  500.                 + "//  - Turn on the option \"Open Attribute Editor In Separate Window\"\n"
  501.                 + "//  - Reselect \"Window > Attribute Editor\"\n//\n"
  502.                 + "// Cannot open AE:  Open Script Editor for more information.";
  503.                 warning ( $errorMessage );
  504.         } else {
  505.             // Take the attribute editor out of the main window
  506.             //
  507.             setAttributeEditorVisible(0);
  508.             eval("openAEWindow");  // to prevent circular reference
  509.         }        
  510.     }
  511. }
  512.  
  513. global proc WindowMenu( string $parent ) {
  514.  
  515.     setParent -m $parent;
  516.     global string $gMiInteractionEditorMenuParent; 
  517.     global string $gMiInteractionEditorMenuAfter;
  518.  
  519.     $gMiInteractionEditorMenuParent = $parent;
  520.  
  521.     string $menu = `menuItem -l "General Editors" -sm true -to true`;
  522.         menu -e -pmc ( "buildObjectEdMenu " + $menu ) $menu;
  523.     setParent -m $parent;
  524.     $menu = `menuItem -l "Rendering Editors" -sm true -to true`;
  525.         menu -e -pmc ( "buildRenderingEdMenu " + $menu ) $menu;
  526.     setParent -m $parent;
  527.     $menu = `menuItem -l "Animation Editors" -sm true -to true`;
  528.         menu -e -pmc ( "buildAnimationEdMenu " + $menu ) $menu;
  529.     setParent -m $parent;
  530.     $menu = `menuItem -l "Relationship Editors" -sm true -to true`;
  531.         menu -e -pmc ( "buildRelationshipEdMenu " + $menu ) $menu;
  532.     setParent -m $parent;
  533.     $menu = `menuItem -l "Settings/Preferences" -sm true -to true`;
  534.         menu -e -pmc ( "buildSettingsMenu " + $menu ) $menu;
  535.     setParent -m $parent;
  536.  
  537.     menuItem -divider true;
  538.  
  539.     menuItem -ecr false -l "Attribute Editor..." 
  540.         -annotation "Attribute Editor: Edit the attributes of the selected object"
  541.         -c "AttributeEditor";
  542.     menuItem -ecr false -l "Outliner..." 
  543.         -annotation "Outliner: List the objects in the scene"
  544.         -c "OutlinerWindow";
  545.     menuItem -ecr false -l "Hypergraph..." 
  546.         -annotation "Hypergraph: Display and edit relationships among nodes in your scene graphically"
  547.         -imageOverlayLabel "Hgph"
  548.         -c "HypergraphWindow";
  549.  
  550.     menuItem -divider true;
  551.  
  552.     if (`licenseCheck -m "edit" -typ "particlePaint"`) {
  553.         menuItem -ecr false -l "Paint Effects..." 
  554.             -annotation "Paint Effects: A 2D/3D paint system using connected particles to produce effects"
  555.             -c "PaintEffectsWindow";
  556.     } else {
  557.         menuItem -ecr false -l "Paint Effects..." 
  558.             -annotation "Paint Effects: A 2D paint system"
  559.             -c "PaintEffectsWindow";
  560.     }        
  561.  
  562.     $gMiInteractionEditorMenuAfter = `menuItem -ecr false -l "UV Texture Editor..." 
  563.         -annotation "UV Texture Editor: Texture coordinate mapping view"
  564.         -c "TextureViewWindow"`;
  565.  
  566.     if( `isTrue AnimationExists` ) {
  567.         menuItem -divider true;
  568.         menuItem -l "Playblast..." 
  569.             -annotation "Playblast: Preview animation by screen-capturing frames"
  570.             -c "PlayblastWindow" playblastItem;
  571.         menuItem -optionBox true 
  572.             -annotation "Playblast Option Box" 
  573.             -l "Playblast Option Box" -c "PlayblastOptions" playblastDialogItem;
  574.     } 
  575. }
  576.